home *** CD-ROM | disk | FTP | other *** search
/ Programming a Multiplayer FPS in DirectX / Programming a Multiplayer FPS in DirectX (Companion CD).iso / DirectX / dxsdk_oct2004.exe / dxsdk.exe / Include / d3dx9math.inl < prev    next >
Encoding:
Text File  |  2004-09-28  |  44.1 KB  |  2,245 lines
  1. //////////////////////////////////////////////////////////////////////////////
  2. //
  3. //  Copyright (C) Microsoft Corporation.  All Rights Reserved.
  4. //
  5. //  File:       d3dx9math.inl
  6. //  Content:    D3DX math inline functions
  7. //
  8. //////////////////////////////////////////////////////////////////////////////
  9.  
  10. #ifndef __D3DX9MATH_INL__
  11. #define __D3DX9MATH_INL__
  12.  
  13.  
  14. //===========================================================================
  15. //
  16. // Inline Class Methods
  17. //
  18. //===========================================================================
  19.  
  20. #ifdef __cplusplus
  21.  
  22. //--------------------------
  23. // Float16
  24. //--------------------------
  25.  
  26. D3DXINLINE
  27. D3DXFLOAT16::D3DXFLOAT16( FLOAT f )
  28. {
  29.     D3DXFloat32To16Array(this, &f, 1);
  30. }
  31.  
  32. D3DXINLINE
  33. D3DXFLOAT16::D3DXFLOAT16( CONST D3DXFLOAT16& f )
  34. {
  35.     value = f.value;
  36. }
  37.  
  38. // casting
  39. D3DXINLINE
  40. D3DXFLOAT16::operator FLOAT ()
  41. {
  42.     FLOAT f;
  43.     D3DXFloat16To32Array(&f, this, 1);
  44.     return f;
  45. }
  46.  
  47. // binary operators
  48. D3DXINLINE BOOL
  49. D3DXFLOAT16::operator == ( CONST D3DXFLOAT16& f ) const
  50. {
  51.     return value == f.value;
  52. }
  53.  
  54. D3DXINLINE BOOL
  55. D3DXFLOAT16::operator != ( CONST D3DXFLOAT16& f ) const
  56. {
  57.     return value != f.value;
  58. }
  59.  
  60.  
  61. //--------------------------
  62. // 2D Vector
  63. //--------------------------
  64.  
  65. D3DXINLINE
  66. D3DXVECTOR2::D3DXVECTOR2( CONST FLOAT *pf )
  67. {
  68. #ifdef D3DX_DEBUG
  69.     if(!pf)
  70.         return;
  71. #endif
  72.  
  73.     x = pf[0];
  74.     y = pf[1];
  75. }
  76.  
  77. D3DXINLINE
  78. D3DXVECTOR2::D3DXVECTOR2( CONST D3DXFLOAT16 *pf )
  79. {
  80. #ifdef D3DX_DEBUG
  81.     if(!pf)
  82.         return;
  83. #endif
  84.  
  85.     D3DXFloat16To32Array(&x, pf, 2);    
  86. }
  87.  
  88. D3DXINLINE
  89. D3DXVECTOR2::D3DXVECTOR2( FLOAT fx, FLOAT fy )
  90. {
  91.     x = fx;
  92.     y = fy;
  93. }
  94.  
  95.  
  96. // casting
  97. D3DXINLINE
  98. D3DXVECTOR2::operator FLOAT* ()
  99. {
  100.     return (FLOAT *) &x;
  101. }
  102.  
  103. D3DXINLINE
  104. D3DXVECTOR2::operator CONST FLOAT* () const
  105. {
  106.     return (CONST FLOAT *) &x;
  107. }
  108.  
  109.  
  110. // assignment operators
  111. D3DXINLINE D3DXVECTOR2&
  112. D3DXVECTOR2::operator += ( CONST D3DXVECTOR2& v )
  113. {
  114.     x += v.x;
  115.     y += v.y;
  116.     return *this;
  117. }
  118.  
  119. D3DXINLINE D3DXVECTOR2&
  120. D3DXVECTOR2::operator -= ( CONST D3DXVECTOR2& v )
  121. {
  122.     x -= v.x;
  123.     y -= v.y;
  124.     return *this;
  125. }
  126.  
  127. D3DXINLINE D3DXVECTOR2&
  128. D3DXVECTOR2::operator *= ( FLOAT f )
  129. {
  130.     x *= f;
  131.     y *= f;
  132.     return *this;
  133. }
  134.  
  135. D3DXINLINE D3DXVECTOR2&
  136. D3DXVECTOR2::operator /= ( FLOAT f )
  137. {
  138.     FLOAT fInv = 1.0f / f;
  139.     x *= fInv;
  140.     y *= fInv;
  141.     return *this;
  142. }
  143.  
  144.  
  145. // unary operators
  146. D3DXINLINE D3DXVECTOR2
  147. D3DXVECTOR2::operator + () const
  148. {
  149.     return *this;
  150. }
  151.  
  152. D3DXINLINE D3DXVECTOR2
  153. D3DXVECTOR2::operator - () const
  154. {
  155.     return D3DXVECTOR2(-x, -y);
  156. }
  157.  
  158.  
  159. // binary operators
  160. D3DXINLINE D3DXVECTOR2
  161. D3DXVECTOR2::operator + ( CONST D3DXVECTOR2& v ) const
  162. {
  163.     return D3DXVECTOR2(x + v.x, y + v.y);
  164. }
  165.  
  166. D3DXINLINE D3DXVECTOR2
  167. D3DXVECTOR2::operator - ( CONST D3DXVECTOR2& v ) const
  168. {
  169.     return D3DXVECTOR2(x - v.x, y - v.y);
  170. }
  171.  
  172. D3DXINLINE D3DXVECTOR2
  173. D3DXVECTOR2::operator * ( FLOAT f ) const
  174. {
  175.     return D3DXVECTOR2(x * f, y * f);
  176. }
  177.  
  178. D3DXINLINE D3DXVECTOR2
  179. D3DXVECTOR2::operator / ( FLOAT f ) const
  180. {
  181.     FLOAT fInv = 1.0f / f;
  182.     return D3DXVECTOR2(x * fInv, y * fInv);
  183. }
  184.  
  185. D3DXINLINE D3DXVECTOR2
  186. operator * ( FLOAT f, CONST D3DXVECTOR2& v )
  187. {
  188.     return D3DXVECTOR2(f * v.x, f * v.y);
  189. }
  190.  
  191. D3DXINLINE BOOL
  192. D3DXVECTOR2::operator == ( CONST D3DXVECTOR2& v ) const
  193. {
  194.     return x == v.x && y == v.y;
  195. }
  196.  
  197. D3DXINLINE BOOL
  198. D3DXVECTOR2::operator != ( CONST D3DXVECTOR2& v ) const
  199. {
  200.     return x != v.x || y != v.y;
  201. }
  202.  
  203.  
  204.  
  205. //--------------------------
  206. // 2D Vector (16 bit)
  207. //--------------------------
  208.  
  209. D3DXINLINE
  210. D3DXVECTOR2_16F::D3DXVECTOR2_16F( CONST FLOAT *pf )
  211. {
  212. #ifdef D3DX_DEBUG
  213.     if(!pf)
  214.         return;
  215. #endif
  216.  
  217.     D3DXFloat32To16Array(&x, pf, 2);
  218. }
  219.  
  220. D3DXINLINE
  221. D3DXVECTOR2_16F::D3DXVECTOR2_16F( CONST D3DXFLOAT16 *pf )
  222. {
  223. #ifdef D3DX_DEBUG
  224.     if(!pf)
  225.         return;
  226. #endif
  227.  
  228.     *((DWORD *) &x) = *((DWORD *) &pf[0]);
  229. }
  230.  
  231. D3DXINLINE
  232. D3DXVECTOR2_16F::D3DXVECTOR2_16F( CONST D3DXFLOAT16 &fx, CONST D3DXFLOAT16 &fy )
  233. {
  234.     x = fx;
  235.     y = fy;
  236. }
  237.  
  238.  
  239. // casting
  240. D3DXINLINE
  241. D3DXVECTOR2_16F::operator D3DXFLOAT16* ()
  242. {
  243.     return (D3DXFLOAT16*) &x;
  244. }
  245.  
  246. D3DXINLINE
  247. D3DXVECTOR2_16F::operator CONST D3DXFLOAT16* () const
  248. {
  249.     return (CONST D3DXFLOAT16*) &x;
  250. }
  251.  
  252.  
  253. // binary operators
  254. D3DXINLINE BOOL 
  255. D3DXVECTOR2_16F::operator == ( CONST D3DXVECTOR2_16F &v ) const
  256. {
  257.     return *((DWORD *) &x) == *((DWORD *) &v.x);
  258. }
  259.  
  260. D3DXINLINE BOOL 
  261. D3DXVECTOR2_16F::operator != ( CONST D3DXVECTOR2_16F &v ) const
  262. {
  263.     return *((DWORD *) &x) != *((DWORD *) &v.x);
  264. }
  265.  
  266.  
  267. //--------------------------
  268. // 3D Vector
  269. //--------------------------
  270. D3DXINLINE
  271. D3DXVECTOR3::D3DXVECTOR3( CONST FLOAT *pf )
  272. {
  273. #ifdef D3DX_DEBUG
  274.     if(!pf)
  275.         return;
  276. #endif
  277.  
  278.     x = pf[0];
  279.     y = pf[1];
  280.     z = pf[2];
  281. }
  282.  
  283. D3DXINLINE
  284. D3DXVECTOR3::D3DXVECTOR3( CONST D3DVECTOR& v )
  285. {
  286.     x = v.x;
  287.     y = v.y;
  288.     z = v.z;
  289. }
  290.  
  291. D3DXINLINE
  292. D3DXVECTOR3::D3DXVECTOR3( CONST D3DXFLOAT16 *pf )
  293. {
  294. #ifdef D3DX_DEBUG
  295.     if(!pf)
  296.         return;
  297. #endif
  298.  
  299.     D3DXFloat16To32Array(&x, pf, 3);
  300. }
  301.  
  302. D3DXINLINE
  303. D3DXVECTOR3::D3DXVECTOR3( FLOAT fx, FLOAT fy, FLOAT fz )
  304. {
  305.     x = fx;
  306.     y = fy;
  307.     z = fz;
  308. }
  309.  
  310.  
  311. // casting
  312. D3DXINLINE
  313. D3DXVECTOR3::operator FLOAT* ()
  314. {
  315.     return (FLOAT *) &x;
  316. }
  317.  
  318. D3DXINLINE
  319. D3DXVECTOR3::operator CONST FLOAT* () const
  320. {
  321.     return (CONST FLOAT *) &x;
  322. }
  323.  
  324.  
  325. // assignment operators
  326. D3DXINLINE D3DXVECTOR3&
  327. D3DXVECTOR3::operator += ( CONST D3DXVECTOR3& v )
  328. {
  329.     x += v.x;
  330.     y += v.y;
  331.     z += v.z;
  332.     return *this;
  333. }
  334.  
  335. D3DXINLINE D3DXVECTOR3&
  336. D3DXVECTOR3::operator -= ( CONST D3DXVECTOR3& v )
  337. {
  338.     x -= v.x;
  339.     y -= v.y;
  340.     z -= v.z;
  341.     return *this;
  342. }
  343.  
  344. D3DXINLINE D3DXVECTOR3&
  345. D3DXVECTOR3::operator *= ( FLOAT f )
  346. {
  347.     x *= f;
  348.     y *= f;
  349.     z *= f;
  350.     return *this;
  351. }
  352.  
  353. D3DXINLINE D3DXVECTOR3&
  354. D3DXVECTOR3::operator /= ( FLOAT f )
  355. {
  356.     FLOAT fInv = 1.0f / f;
  357.     x *= fInv;
  358.     y *= fInv;
  359.     z *= fInv;
  360.     return *this;
  361. }
  362.  
  363.  
  364. // unary operators
  365. D3DXINLINE D3DXVECTOR3
  366. D3DXVECTOR3::operator + () const
  367. {
  368.     return *this;
  369. }
  370.  
  371. D3DXINLINE D3DXVECTOR3
  372. D3DXVECTOR3::operator - () const
  373. {
  374.     return D3DXVECTOR3(-x, -y, -z);
  375. }
  376.  
  377.  
  378. // binary operators
  379. D3DXINLINE D3DXVECTOR3
  380. D3DXVECTOR3::operator + ( CONST D3DXVECTOR3& v ) const
  381. {
  382.     return D3DXVECTOR3(x + v.x, y + v.y, z + v.z);
  383. }
  384.  
  385. D3DXINLINE D3DXVECTOR3
  386. D3DXVECTOR3::operator - ( CONST D3DXVECTOR3& v ) const
  387. {
  388.     return D3DXVECTOR3(x - v.x, y - v.y, z - v.z);
  389. }
  390.  
  391. D3DXINLINE D3DXVECTOR3
  392. D3DXVECTOR3::operator * ( FLOAT f ) const
  393. {
  394.     return D3DXVECTOR3(x * f, y * f, z * f);
  395. }
  396.  
  397. D3DXINLINE D3DXVECTOR3
  398. D3DXVECTOR3::operator / ( FLOAT f ) const
  399. {
  400.     FLOAT fInv = 1.0f / f;
  401.     return D3DXVECTOR3(x * fInv, y * fInv, z * fInv);
  402. }
  403.  
  404.  
  405. D3DXINLINE D3DXVECTOR3
  406. operator * ( FLOAT f, CONST struct D3DXVECTOR3& v )
  407. {
  408.     return D3DXVECTOR3(f * v.x, f * v.y, f * v.z);
  409. }
  410.  
  411.  
  412. D3DXINLINE BOOL
  413. D3DXVECTOR3::operator == ( CONST D3DXVECTOR3& v ) const
  414. {
  415.     return x == v.x && y == v.y && z == v.z;
  416. }
  417.  
  418. D3DXINLINE BOOL
  419. D3DXVECTOR3::operator != ( CONST D3DXVECTOR3& v ) const
  420. {
  421.     return x != v.x || y != v.y || z != v.z;
  422. }
  423.  
  424.  
  425.  
  426. //--------------------------
  427. // 3D Vector (16 bit)
  428. //--------------------------
  429.  
  430. D3DXINLINE
  431. D3DXVECTOR3_16F::D3DXVECTOR3_16F( CONST FLOAT *pf )
  432. {
  433. #ifdef D3DX_DEBUG
  434.     if(!pf)
  435.         return;
  436. #endif
  437.  
  438.     D3DXFloat32To16Array(&x, pf, 3);
  439. }
  440.  
  441. D3DXINLINE
  442. D3DXVECTOR3_16F::D3DXVECTOR3_16F( CONST D3DVECTOR& v )
  443. {
  444.     D3DXFloat32To16Array(&x, &v.x, 1);
  445.     D3DXFloat32To16Array(&y, &v.y, 1);
  446.     D3DXFloat32To16Array(&z, &v.z, 1);
  447. }
  448.  
  449. D3DXINLINE
  450. D3DXVECTOR3_16F::D3DXVECTOR3_16F( CONST D3DXFLOAT16 *pf )
  451. {
  452. #ifdef D3DX_DEBUG
  453.     if(!pf)
  454.         return;
  455. #endif
  456.  
  457.     *((DWORD *) &x) = *((DWORD *) &pf[0]);
  458.     *((WORD  *) &z) = *((WORD  *) &pf[2]);
  459. }
  460.  
  461. D3DXINLINE
  462. D3DXVECTOR3_16F::D3DXVECTOR3_16F( CONST D3DXFLOAT16 &fx, CONST D3DXFLOAT16 &fy, CONST D3DXFLOAT16 &fz )
  463. {
  464.     x = fx;
  465.     y = fy;
  466.     z = fz;
  467. }
  468.  
  469.  
  470. // casting
  471. D3DXINLINE
  472. D3DXVECTOR3_16F::operator D3DXFLOAT16* ()
  473. {
  474.     return (D3DXFLOAT16*) &x;
  475. }
  476.  
  477. D3DXINLINE
  478. D3DXVECTOR3_16F::operator CONST D3DXFLOAT16* () const
  479. {
  480.     return (CONST D3DXFLOAT16*) &x;
  481. }
  482.  
  483.  
  484. // binary operators
  485. D3DXINLINE BOOL 
  486. D3DXVECTOR3_16F::operator == ( CONST D3DXVECTOR3_16F &v ) const
  487. {
  488.     return *((DWORD *) &x) == *((DWORD *) &v.x) &&
  489.            *((WORD  *) &z) == *((WORD  *) &v.z);
  490. }
  491.  
  492. D3DXINLINE BOOL 
  493. D3DXVECTOR3_16F::operator != ( CONST D3DXVECTOR3_16F &v ) const
  494. {
  495.     return *((DWORD *) &x) != *((DWORD *) &v.x) ||
  496.            *((WORD  *) &z) != *((WORD  *) &v.z);
  497. }
  498.  
  499.  
  500. //--------------------------
  501. // 4D Vector
  502. //--------------------------
  503. D3DXINLINE
  504. D3DXVECTOR4::D3DXVECTOR4( CONST FLOAT *pf )
  505. {
  506. #ifdef D3DX_DEBUG
  507.     if(!pf)
  508.         return;
  509. #endif
  510.  
  511.     x = pf[0];
  512.     y = pf[1];
  513.     z = pf[2];
  514.     w = pf[3];
  515. }
  516.  
  517. D3DXINLINE
  518. D3DXVECTOR4::D3DXVECTOR4( CONST D3DXFLOAT16 *pf )
  519. {
  520. #ifdef D3DX_DEBUG
  521.     if(!pf)
  522.         return;
  523. #endif
  524.  
  525.     D3DXFloat16To32Array(&x, pf, 4);
  526. }
  527.  
  528. D3DXINLINE
  529. D3DXVECTOR4::D3DXVECTOR4( CONST D3DVECTOR& v, FLOAT f )
  530. {
  531.     x = v.x;
  532.     y = v.y;
  533.     z = v.z;
  534.     w = f;
  535. }
  536.  
  537. D3DXINLINE
  538. D3DXVECTOR4::D3DXVECTOR4( FLOAT fx, FLOAT fy, FLOAT fz, FLOAT fw )
  539. {
  540.     x = fx;
  541.     y = fy;
  542.     z = fz;
  543.     w = fw;
  544. }
  545.  
  546.  
  547. // casting
  548. D3DXINLINE
  549. D3DXVECTOR4::operator FLOAT* ()
  550. {
  551.     return (FLOAT *) &x;
  552. }
  553.  
  554. D3DXINLINE
  555. D3DXVECTOR4::operator CONST FLOAT* () const
  556. {
  557.     return (CONST FLOAT *) &x;
  558. }
  559.  
  560.  
  561. // assignment operators
  562. D3DXINLINE D3DXVECTOR4&
  563. D3DXVECTOR4::operator += ( CONST D3DXVECTOR4& v )
  564. {
  565.     x += v.x;
  566.     y += v.y;
  567.     z += v.z;
  568.     w += v.w;
  569.     return *this;
  570. }
  571.  
  572. D3DXINLINE D3DXVECTOR4&
  573. D3DXVECTOR4::operator -= ( CONST D3DXVECTOR4& v )
  574. {
  575.     x -= v.x;
  576.     y -= v.y;
  577.     z -= v.z;
  578.     w -= v.w;
  579.     return *this;
  580. }
  581.  
  582. D3DXINLINE D3DXVECTOR4&
  583. D3DXVECTOR4::operator *= ( FLOAT f )
  584. {
  585.     x *= f;
  586.     y *= f;
  587.     z *= f;
  588.     w *= f;
  589.     return *this;
  590. }
  591.  
  592. D3DXINLINE D3DXVECTOR4&
  593. D3DXVECTOR4::operator /= ( FLOAT f )
  594. {
  595.     FLOAT fInv = 1.0f / f;
  596.     x *= fInv;
  597.     y *= fInv;
  598.     z *= fInv;
  599.     w *= fInv;
  600.     return *this;
  601. }
  602.  
  603.  
  604. // unary operators
  605. D3DXINLINE D3DXVECTOR4
  606. D3DXVECTOR4::operator + () const
  607. {
  608.     return *this;
  609. }
  610.  
  611. D3DXINLINE D3DXVECTOR4
  612. D3DXVECTOR4::operator - () const
  613. {
  614.     return D3DXVECTOR4(-x, -y, -z, -w);
  615. }
  616.  
  617.  
  618. // binary operators
  619. D3DXINLINE D3DXVECTOR4
  620. D3DXVECTOR4::operator + ( CONST D3DXVECTOR4& v ) const
  621. {
  622.     return D3DXVECTOR4(x + v.x, y + v.y, z + v.z, w + v.w);
  623. }
  624.  
  625. D3DXINLINE D3DXVECTOR4
  626. D3DXVECTOR4::operator - ( CONST D3DXVECTOR4& v ) const
  627. {
  628.     return D3DXVECTOR4(x - v.x, y - v.y, z - v.z, w - v.w);
  629. }
  630.  
  631. D3DXINLINE D3DXVECTOR4
  632. D3DXVECTOR4::operator * ( FLOAT f ) const
  633. {
  634.     return D3DXVECTOR4(x * f, y * f, z * f, w * f);
  635. }
  636.  
  637. D3DXINLINE D3DXVECTOR4
  638. D3DXVECTOR4::operator / ( FLOAT f ) const
  639. {
  640.     FLOAT fInv = 1.0f / f;
  641.     return D3DXVECTOR4(x * fInv, y * fInv, z * fInv, w * fInv);
  642. }
  643.  
  644. D3DXINLINE D3DXVECTOR4
  645. operator * ( FLOAT f, CONST D3DXVECTOR4& v )
  646. {
  647.     return D3DXVECTOR4(f * v.x, f * v.y, f * v.z, f * v.w);
  648. }
  649.  
  650.  
  651. D3DXINLINE BOOL
  652. D3DXVECTOR4::operator == ( CONST D3DXVECTOR4& v ) const
  653. {
  654.     return x == v.x && y == v.y && z == v.z && w == v.w;
  655. }
  656.  
  657. D3DXINLINE BOOL
  658. D3DXVECTOR4::operator != ( CONST D3DXVECTOR4& v ) const
  659. {
  660.     return x != v.x || y != v.y || z != v.z || w != v.w;
  661. }
  662.  
  663.  
  664.  
  665. //--------------------------
  666. // 4D Vector (16 bit)
  667. //--------------------------
  668.  
  669. D3DXINLINE
  670. D3DXVECTOR4_16F::D3DXVECTOR4_16F( CONST FLOAT *pf )
  671. {
  672. #ifdef D3DX_DEBUG
  673.     if(!pf)
  674.         return;
  675. #endif
  676.  
  677.     D3DXFloat32To16Array(&x, pf, 4);
  678. }
  679.  
  680. D3DXINLINE
  681. D3DXVECTOR4_16F::D3DXVECTOR4_16F( CONST D3DXFLOAT16 *pf )
  682. {
  683. #ifdef D3DX_DEBUG
  684.     if(!pf)
  685.         return;
  686. #endif
  687.  
  688.     *((DWORD *) &x) = *((DWORD *) &pf[0]);
  689.     *((DWORD *) &z) = *((DWORD *) &pf[2]);
  690. }
  691.  
  692. D3DXINLINE
  693. D3DXVECTOR4_16F::D3DXVECTOR4_16F( CONST D3DXVECTOR3_16F& v, CONST D3DXFLOAT16& f )
  694. {
  695.     x = v.x;
  696.     y = v.y;
  697.     z = v.z;
  698.     w = f;
  699. }
  700.  
  701. D3DXINLINE
  702. D3DXVECTOR4_16F::D3DXVECTOR4_16F( CONST D3DXFLOAT16 &fx, CONST D3DXFLOAT16 &fy, CONST D3DXFLOAT16 &fz, CONST D3DXFLOAT16 &fw )
  703. {
  704.     x = fx;
  705.     y = fy;
  706.     z = fz;
  707.     w = fw;
  708. }
  709.  
  710.  
  711. // casting
  712. D3DXINLINE
  713. D3DXVECTOR4_16F::operator D3DXFLOAT16* ()
  714. {
  715.     return (D3DXFLOAT16*) &x;
  716. }
  717.  
  718. D3DXINLINE
  719. D3DXVECTOR4_16F::operator CONST D3DXFLOAT16* () const
  720. {
  721.     return (CONST D3DXFLOAT16*) &x;
  722. }
  723.  
  724.  
  725. // binary operators
  726. D3DXINLINE BOOL 
  727. D3DXVECTOR4_16F::operator == ( CONST D3DXVECTOR4_16F &v ) const
  728. {
  729.     return *((DWORD *) &x) == *((DWORD *) &v.x) &&
  730.            *((DWORD *) &z) == *((DWORD *) &v.z);
  731. }
  732.  
  733. D3DXINLINE BOOL 
  734. D3DXVECTOR4_16F::operator != ( CONST D3DXVECTOR4_16F &v ) const
  735. {
  736.     return *((DWORD *) &x) != *((DWORD *) &v.x) ||
  737.            *((DWORD *) &z) != *((DWORD *) &v.z);
  738. }
  739.  
  740.  
  741. //--------------------------
  742. // Matrix
  743. //--------------------------
  744. D3DXINLINE
  745. D3DXMATRIX::D3DXMATRIX( CONST FLOAT* pf )
  746. {
  747. #ifdef D3DX_DEBUG
  748.     if(!pf)
  749.         return;
  750. #endif
  751.  
  752.     memcpy(&_11, pf, sizeof(D3DXMATRIX));
  753. }
  754.  
  755. D3DXINLINE
  756. D3DXMATRIX::D3DXMATRIX( CONST D3DMATRIX& mat )
  757. {
  758.     memcpy(&_11, &mat, sizeof(D3DXMATRIX));
  759. }
  760.  
  761. D3DXINLINE
  762. D3DXMATRIX::D3DXMATRIX( CONST D3DXFLOAT16* pf )
  763. {
  764. #ifdef D3DX_DEBUG
  765.     if(!pf)
  766.         return;
  767. #endif
  768.  
  769.     D3DXFloat16To32Array(&_11, pf, 16);
  770. }
  771.  
  772. D3DXINLINE
  773. D3DXMATRIX::D3DXMATRIX( FLOAT f11, FLOAT f12, FLOAT f13, FLOAT f14,
  774.                         FLOAT f21, FLOAT f22, FLOAT f23, FLOAT f24,
  775.                         FLOAT f31, FLOAT f32, FLOAT f33, FLOAT f34,
  776.                         FLOAT f41, FLOAT f42, FLOAT f43, FLOAT f44 )
  777. {
  778.     _11 = f11; _12 = f12; _13 = f13; _14 = f14;
  779.     _21 = f21; _22 = f22; _23 = f23; _24 = f24;
  780.     _31 = f31; _32 = f32; _33 = f33; _34 = f34;
  781.     _41 = f41; _42 = f42; _43 = f43; _44 = f44;
  782. }
  783.  
  784.  
  785.  
  786. // access grants
  787. D3DXINLINE FLOAT&
  788. D3DXMATRIX::operator () ( UINT iRow, UINT iCol )
  789. {
  790.     return m[iRow][iCol];
  791. }
  792.  
  793. D3DXINLINE FLOAT
  794. D3DXMATRIX::operator () ( UINT iRow, UINT iCol ) const
  795. {
  796.     return m[iRow][iCol];
  797. }
  798.  
  799.  
  800. // casting operators
  801. D3DXINLINE
  802. D3DXMATRIX::operator FLOAT* ()
  803. {
  804.     return (FLOAT *) &_11;
  805. }
  806.  
  807. D3DXINLINE
  808. D3DXMATRIX::operator CONST FLOAT* () const
  809. {
  810.     return (CONST FLOAT *) &_11;
  811. }
  812.  
  813.  
  814. // assignment operators
  815. D3DXINLINE D3DXMATRIX&
  816. D3DXMATRIX::operator *= ( CONST D3DXMATRIX& mat )
  817. {
  818.     D3DXMatrixMultiply(this, this, &mat);
  819.     return *this;
  820. }
  821.  
  822. D3DXINLINE D3DXMATRIX&
  823. D3DXMATRIX::operator += ( CONST D3DXMATRIX& mat )
  824. {
  825.     _11 += mat._11; _12 += mat._12; _13 += mat._13; _14 += mat._14;
  826.     _21 += mat._21; _22 += mat._22; _23 += mat._23; _24 += mat._24;
  827.     _31 += mat._31; _32 += mat._32; _33 += mat._33; _34 += mat._34;
  828.     _41 += mat._41; _42 += mat._42; _43 += mat._43; _44 += mat._44;
  829.     return *this;
  830. }
  831.  
  832. D3DXINLINE D3DXMATRIX&
  833. D3DXMATRIX::operator -= ( CONST D3DXMATRIX& mat )
  834. {
  835.     _11 -= mat._11; _12 -= mat._12; _13 -= mat._13; _14 -= mat._14;
  836.     _21 -= mat._21; _22 -= mat._22; _23 -= mat._23; _24 -= mat._24;
  837.     _31 -= mat._31; _32 -= mat._32; _33 -= mat._33; _34 -= mat._34;
  838.     _41 -= mat._41; _42 -= mat._42; _43 -= mat._43; _44 -= mat._44;
  839.     return *this;
  840. }
  841.  
  842. D3DXINLINE D3DXMATRIX&
  843. D3DXMATRIX::operator *= ( FLOAT f )
  844. {
  845.     _11 *= f; _12 *= f; _13 *= f; _14 *= f;
  846.     _21 *= f; _22 *= f; _23 *= f; _24 *= f;
  847.     _31 *= f; _32 *= f; _33 *= f; _34 *= f;
  848.     _41 *= f; _42 *= f; _43 *= f; _44 *= f;
  849.     return *this;
  850. }
  851.  
  852. D3DXINLINE D3DXMATRIX&
  853. D3DXMATRIX::operator /= ( FLOAT f )
  854. {
  855.     FLOAT fInv = 1.0f / f;
  856.     _11 *= fInv; _12 *= fInv; _13 *= fInv; _14 *= fInv;
  857.     _21 *= fInv; _22 *= fInv; _23 *= fInv; _24 *= fInv;
  858.     _31 *= fInv; _32 *= fInv; _33 *= fInv; _34 *= fInv;
  859.     _41 *= fInv; _42 *= fInv; _43 *= fInv; _44 *= fInv;
  860.     return *this;
  861. }
  862.  
  863.  
  864. // unary operators
  865. D3DXINLINE D3DXMATRIX
  866. D3DXMATRIX::operator + () const
  867. {
  868.     return *this;
  869. }
  870.  
  871. D3DXINLINE D3DXMATRIX
  872. D3DXMATRIX::operator - () const
  873. {
  874.     return D3DXMATRIX(-_11, -_12, -_13, -_14,
  875.                       -_21, -_22, -_23, -_24,
  876.                       -_31, -_32, -_33, -_34,
  877.                       -_41, -_42, -_43, -_44);
  878. }
  879.  
  880.  
  881. // binary operators
  882. D3DXINLINE D3DXMATRIX
  883. D3DXMATRIX::operator * ( CONST D3DXMATRIX& mat ) const
  884. {
  885.     D3DXMATRIX matT;
  886.     D3DXMatrixMultiply(&matT, this, &mat);
  887.     return matT;
  888. }
  889.  
  890. D3DXINLINE D3DXMATRIX
  891. D3DXMATRIX::operator + ( CONST D3DXMATRIX& mat ) const
  892. {
  893.     return D3DXMATRIX(_11 + mat._11, _12 + mat._12, _13 + mat._13, _14 + mat._14,
  894.                       _21 + mat._21, _22 + mat._22, _23 + mat._23, _24 + mat._24,
  895.                       _31 + mat._31, _32 + mat._32, _33 + mat._33, _34 + mat._34,
  896.                       _41 + mat._41, _42 + mat._42, _43 + mat._43, _44 + mat._44);
  897. }
  898.  
  899. D3DXINLINE D3DXMATRIX
  900. D3DXMATRIX::operator - ( CONST D3DXMATRIX& mat ) const
  901. {
  902.     return D3DXMATRIX(_11 - mat._11, _12 - mat._12, _13 - mat._13, _14 - mat._14,
  903.                       _21 - mat._21, _22 - mat._22, _23 - mat._23, _24 - mat._24,
  904.                       _31 - mat._31, _32 - mat._32, _33 - mat._33, _34 - mat._34,
  905.                       _41 - mat._41, _42 - mat._42, _43 - mat._43, _44 - mat._44);
  906. }
  907.  
  908. D3DXINLINE D3DXMATRIX
  909. D3DXMATRIX::operator * ( FLOAT f ) const
  910. {
  911.     return D3DXMATRIX(_11 * f, _12 * f, _13 * f, _14 * f,
  912.                       _21 * f, _22 * f, _23 * f, _24 * f,
  913.                       _31 * f, _32 * f, _33 * f, _34 * f,
  914.                       _41 * f, _42 * f, _43 * f, _44 * f);
  915. }
  916.  
  917. D3DXINLINE D3DXMATRIX
  918. D3DXMATRIX::operator / ( FLOAT f ) const
  919. {
  920.     FLOAT fInv = 1.0f / f;
  921.     return D3DXMATRIX(_11 * fInv, _12 * fInv, _13 * fInv, _14 * fInv,
  922.                       _21 * fInv, _22 * fInv, _23 * fInv, _24 * fInv,
  923.                       _31 * fInv, _32 * fInv, _33 * fInv, _34 * fInv,
  924.                       _41 * fInv, _42 * fInv, _43 * fInv, _44 * fInv);
  925. }
  926.  
  927.  
  928. D3DXINLINE D3DXMATRIX
  929. operator * ( FLOAT f, CONST D3DXMATRIX& mat )
  930. {
  931.     return D3DXMATRIX(f * mat._11, f * mat._12, f * mat._13, f * mat._14,
  932.                       f * mat._21, f * mat._22, f * mat._23, f * mat._24,
  933.                       f * mat._31, f * mat._32, f * mat._33, f * mat._34,
  934.                       f * mat._41, f * mat._42, f * mat._43, f * mat._44);
  935. }
  936.  
  937.  
  938. D3DXINLINE BOOL
  939. D3DXMATRIX::operator == ( CONST D3DXMATRIX& mat ) const
  940. {
  941.     return 0 == memcmp(this, &mat, sizeof(D3DXMATRIX));
  942. }
  943.  
  944. D3DXINLINE BOOL
  945. D3DXMATRIX::operator != ( CONST D3DXMATRIX& mat ) const
  946. {
  947.     return 0 != memcmp(this, &mat, sizeof(D3DXMATRIX));
  948. }
  949.  
  950.  
  951.  
  952. //--------------------------
  953. // Aligned Matrices
  954. //--------------------------
  955.  
  956. D3DXINLINE
  957. _D3DXMATRIXA16::_D3DXMATRIXA16( CONST FLOAT* f ) : 
  958.     D3DXMATRIX( f ) 
  959. {
  960. }
  961.  
  962. D3DXINLINE
  963. _D3DXMATRIXA16::_D3DXMATRIXA16( CONST D3DMATRIX& m ) : 
  964.     D3DXMATRIX( m ) 
  965. {
  966. }
  967.  
  968. D3DXINLINE
  969. _D3DXMATRIXA16::_D3DXMATRIXA16( CONST D3DXFLOAT16* f ) : 
  970.     D3DXMATRIX( f ) 
  971. {
  972. }
  973.  
  974. D3DXINLINE
  975. _D3DXMATRIXA16::_D3DXMATRIXA16( FLOAT _11, FLOAT _12, FLOAT _13, FLOAT _14,
  976.                                 FLOAT _21, FLOAT _22, FLOAT _23, FLOAT _24,
  977.                                 FLOAT _31, FLOAT _32, FLOAT _33, FLOAT _34,
  978.                                 FLOAT _41, FLOAT _42, FLOAT _43, FLOAT _44 ) :
  979.     D3DXMATRIX(_11, _12, _13, _14,
  980.                _21, _22, _23, _24,
  981.                _31, _32, _33, _34,
  982.                _41, _42, _43, _44) 
  983. {
  984. }
  985.  
  986. D3DXINLINE void* 
  987. _D3DXMATRIXA16::operator new( size_t s )
  988. {
  989.     LPBYTE p = ::new BYTE[s + 16];
  990.     if (p)
  991.     {
  992.         BYTE offset = (BYTE)(16 - ((UINT_PTR)p & 15));
  993.         p += offset;
  994.         p[-1] = offset;
  995.     }
  996.     return p;
  997. }
  998.  
  999. D3DXINLINE void* 
  1000. _D3DXMATRIXA16::operator new[]( size_t s )
  1001. {
  1002.     LPBYTE p = ::new BYTE[s + 16];
  1003.     if (p)
  1004.     {
  1005.         BYTE offset = (BYTE)(16 - ((UINT_PTR)p & 15));
  1006.         p += offset;
  1007.         p[-1] = offset;
  1008.     }
  1009.     return p;
  1010. }
  1011.  
  1012. D3DXINLINE void 
  1013. _D3DXMATRIXA16::operator delete(void* p)
  1014. {
  1015.     if(p)
  1016.     {
  1017.         BYTE* pb = static_cast<BYTE*>(p);
  1018.         pb -= pb[-1];
  1019.         ::delete [] pb;
  1020.     }
  1021. }
  1022.  
  1023. D3DXINLINE void 
  1024. _D3DXMATRIXA16::operator delete[](void* p)
  1025. {
  1026.     if(p)
  1027.     {
  1028.         BYTE* pb = static_cast<BYTE*>(p);
  1029.         pb -= pb[-1];
  1030.         ::delete [] pb;
  1031.     }
  1032. }
  1033.  
  1034. D3DXINLINE _D3DXMATRIXA16& 
  1035. _D3DXMATRIXA16::operator=(CONST D3DXMATRIX& rhs)
  1036. {
  1037.     memcpy(&_11, &rhs, sizeof(D3DXMATRIX));
  1038.     return *this;
  1039. }
  1040.  
  1041.  
  1042. //--------------------------
  1043. // Quaternion
  1044. //--------------------------
  1045.  
  1046. D3DXINLINE
  1047. D3DXQUATERNION::D3DXQUATERNION( CONST FLOAT* pf )
  1048. {
  1049. #ifdef D3DX_DEBUG
  1050.     if(!pf)
  1051.         return;
  1052. #endif
  1053.  
  1054.     x = pf[0];
  1055.     y = pf[1];
  1056.     z = pf[2];
  1057.     w = pf[3];
  1058. }
  1059.  
  1060. D3DXINLINE
  1061. D3DXQUATERNION::D3DXQUATERNION( CONST D3DXFLOAT16* pf )
  1062. {
  1063. #ifdef D3DX_DEBUG
  1064.     if(!pf)
  1065.         return;
  1066. #endif
  1067.  
  1068.     D3DXFloat16To32Array(&x, pf, 4);
  1069. }
  1070.  
  1071. D3DXINLINE
  1072. D3DXQUATERNION::D3DXQUATERNION( FLOAT fx, FLOAT fy, FLOAT fz, FLOAT fw )
  1073. {
  1074.     x = fx;
  1075.     y = fy;
  1076.     z = fz;
  1077.     w = fw;
  1078. }
  1079.  
  1080.  
  1081. // casting
  1082. D3DXINLINE
  1083. D3DXQUATERNION::operator FLOAT* ()
  1084. {
  1085.     return (FLOAT *) &x;
  1086. }
  1087.  
  1088. D3DXINLINE
  1089. D3DXQUATERNION::operator CONST FLOAT* () const
  1090. {
  1091.     return (CONST FLOAT *) &x;
  1092. }
  1093.  
  1094.  
  1095. // assignment operators
  1096. D3DXINLINE D3DXQUATERNION&
  1097. D3DXQUATERNION::operator += ( CONST D3DXQUATERNION& q )
  1098. {
  1099.     x += q.x;
  1100.     y += q.y;
  1101.     z += q.z;
  1102.     w += q.w;
  1103.     return *this;
  1104. }
  1105.  
  1106. D3DXINLINE D3DXQUATERNION&
  1107. D3DXQUATERNION::operator -= ( CONST D3DXQUATERNION& q )
  1108. {
  1109.     x -= q.x;
  1110.     y -= q.y;
  1111.     z -= q.z;
  1112.     w -= q.w;
  1113.     return *this;
  1114. }
  1115.  
  1116. D3DXINLINE D3DXQUATERNION&
  1117. D3DXQUATERNION::operator *= ( CONST D3DXQUATERNION& q )
  1118. {
  1119.     D3DXQuaternionMultiply(this, this, &q);
  1120.     return *this;
  1121. }
  1122.  
  1123. D3DXINLINE D3DXQUATERNION&
  1124. D3DXQUATERNION::operator *= ( FLOAT f )
  1125. {
  1126.     x *= f;
  1127.     y *= f;
  1128.     z *= f;
  1129.     w *= f;
  1130.     return *this;
  1131. }
  1132.  
  1133. D3DXINLINE D3DXQUATERNION&
  1134. D3DXQUATERNION::operator /= ( FLOAT f )
  1135. {
  1136.     FLOAT fInv = 1.0f / f;
  1137.     x *= fInv;
  1138.     y *= fInv;
  1139.     z *= fInv;
  1140.     w *= fInv;
  1141.     return *this;
  1142. }
  1143.  
  1144.  
  1145. // unary operators
  1146. D3DXINLINE D3DXQUATERNION
  1147. D3DXQUATERNION::operator + () const
  1148. {
  1149.     return *this;
  1150. }
  1151.  
  1152. D3DXINLINE D3DXQUATERNION
  1153. D3DXQUATERNION::operator - () const
  1154. {
  1155.     return D3DXQUATERNION(-x, -y, -z, -w);
  1156. }
  1157.  
  1158.  
  1159. // binary operators
  1160. D3DXINLINE D3DXQUATERNION
  1161. D3DXQUATERNION::operator + ( CONST D3DXQUATERNION& q ) const
  1162. {
  1163.     return D3DXQUATERNION(x + q.x, y + q.y, z + q.z, w + q.w);
  1164. }
  1165.  
  1166. D3DXINLINE D3DXQUATERNION
  1167. D3DXQUATERNION::operator - ( CONST D3DXQUATERNION& q ) const
  1168. {
  1169.     return D3DXQUATERNION(x - q.x, y - q.y, z - q.z, w - q.w);
  1170. }
  1171.  
  1172. D3DXINLINE D3DXQUATERNION
  1173. D3DXQUATERNION::operator * ( CONST D3DXQUATERNION& q ) const
  1174. {
  1175.     D3DXQUATERNION qT;
  1176.     D3DXQuaternionMultiply(&qT, this, &q);
  1177.     return qT;
  1178. }
  1179.  
  1180. D3DXINLINE D3DXQUATERNION
  1181. D3DXQUATERNION::operator * ( FLOAT f ) const
  1182. {
  1183.     return D3DXQUATERNION(x * f, y * f, z * f, w * f);
  1184. }
  1185.  
  1186. D3DXINLINE D3DXQUATERNION
  1187. D3DXQUATERNION::operator / ( FLOAT f ) const
  1188. {
  1189.     FLOAT fInv = 1.0f / f;
  1190.     return D3DXQUATERNION(x * fInv, y * fInv, z * fInv, w * fInv);
  1191. }
  1192.  
  1193.  
  1194. D3DXINLINE D3DXQUATERNION
  1195. operator * (FLOAT f, CONST D3DXQUATERNION& q )
  1196. {
  1197.     return D3DXQUATERNION(f * q.x, f * q.y, f * q.z, f * q.w);
  1198. }
  1199.  
  1200.  
  1201. D3DXINLINE BOOL
  1202. D3DXQUATERNION::operator == ( CONST D3DXQUATERNION& q ) const
  1203. {
  1204.     return x == q.x && y == q.y && z == q.z && w == q.w;
  1205. }
  1206.  
  1207. D3DXINLINE BOOL
  1208. D3DXQUATERNION::operator != ( CONST D3DXQUATERNION& q ) const
  1209. {
  1210.     return x != q.x || y != q.y || z != q.z || w != q.w;
  1211. }
  1212.  
  1213.  
  1214.  
  1215. //--------------------------
  1216. // Plane
  1217. //--------------------------
  1218.  
  1219. D3DXINLINE
  1220. D3DXPLANE::D3DXPLANE( CONST FLOAT* pf )
  1221. {
  1222. #ifdef D3DX_DEBUG
  1223.     if(!pf)
  1224.         return;
  1225. #endif
  1226.  
  1227.     a = pf[0];
  1228.     b = pf[1];
  1229.     c = pf[2];
  1230.     d = pf[3];
  1231. }
  1232.  
  1233. D3DXINLINE
  1234. D3DXPLANE::D3DXPLANE( CONST D3DXFLOAT16* pf )
  1235. {
  1236. #ifdef D3DX_DEBUG
  1237.     if(!pf)
  1238.         return;
  1239. #endif
  1240.  
  1241.     D3DXFloat16To32Array(&a, pf, 4);
  1242. }
  1243.  
  1244. D3DXINLINE
  1245. D3DXPLANE::D3DXPLANE( FLOAT fa, FLOAT fb, FLOAT fc, FLOAT fd )
  1246. {
  1247.     a = fa;
  1248.     b = fb;
  1249.     c = fc;
  1250.     d = fd;
  1251. }
  1252.  
  1253.  
  1254. // casting
  1255. D3DXINLINE
  1256. D3DXPLANE::operator FLOAT* ()
  1257. {
  1258.     return (FLOAT *) &a;
  1259. }
  1260.  
  1261. D3DXINLINE
  1262. D3DXPLANE::operator CONST FLOAT* () const
  1263. {
  1264.     return (CONST FLOAT *) &a;
  1265. }
  1266.  
  1267.  
  1268. // assignment operators
  1269. D3DXINLINE D3DXPLANE&
  1270. D3DXPLANE::operator *= ( FLOAT f )
  1271. {
  1272.     a *= f;
  1273.     b *= f;
  1274.     c *= f;
  1275.     d *= f;
  1276.     return *this;
  1277. }
  1278.  
  1279. D3DXINLINE D3DXPLANE&
  1280. D3DXPLANE::operator /= ( FLOAT f )
  1281. {
  1282.     FLOAT fInv = 1.0f / f;
  1283.     a *= fInv;
  1284.     b *= fInv;
  1285.     c *= fInv;
  1286.     d *= fInv;
  1287.     return *this;
  1288. }
  1289.  
  1290.  
  1291. // unary operators
  1292. D3DXINLINE D3DXPLANE
  1293. D3DXPLANE::operator + () const
  1294. {
  1295.     return *this;
  1296. }
  1297.  
  1298. D3DXINLINE D3DXPLANE
  1299. D3DXPLANE::operator - () const
  1300. {
  1301.     return D3DXPLANE(-a, -b, -c, -d);
  1302. }
  1303.  
  1304.  
  1305. // binary operators
  1306. D3DXINLINE D3DXPLANE
  1307. D3DXPLANE::operator * ( FLOAT f ) const
  1308. {
  1309.     return D3DXPLANE(a * f, b * f, c * f, d * f);
  1310. }
  1311.  
  1312. D3DXINLINE D3DXPLANE
  1313. D3DXPLANE::operator / ( FLOAT f ) const
  1314. {
  1315.     FLOAT fInv = 1.0f / f;
  1316.     return D3DXPLANE(a * fInv, b * fInv, c * fInv, d * fInv);
  1317. }
  1318.  
  1319. D3DXINLINE D3DXPLANE
  1320. operator * (FLOAT f, CONST D3DXPLANE& p )
  1321. {
  1322.     return D3DXPLANE(f * p.a, f * p.b, f * p.c, f * p.d);
  1323. }
  1324.  
  1325. D3DXINLINE BOOL
  1326. D3DXPLANE::operator == ( CONST D3DXPLANE& p ) const
  1327. {
  1328.     return a == p.a && b == p.b && c == p.c && d == p.d;
  1329. }
  1330.  
  1331. D3DXINLINE BOOL
  1332. D3DXPLANE::operator != ( CONST D3DXPLANE& p ) const
  1333. {
  1334.     return a != p.a || b != p.b || c != p.c || d != p.d;
  1335. }
  1336.  
  1337.  
  1338.  
  1339.  
  1340. //--------------------------
  1341. // Color
  1342. //--------------------------
  1343.  
  1344. D3DXINLINE
  1345. D3DXCOLOR::D3DXCOLOR( DWORD dw )
  1346. {
  1347.     CONST FLOAT f = 1.0f / 255.0f;
  1348.     r = f * (FLOAT) (unsigned char) (dw >> 16);
  1349.     g = f * (FLOAT) (unsigned char) (dw >>  8);
  1350.     b = f * (FLOAT) (unsigned char) (dw >>  0);
  1351.     a = f * (FLOAT) (unsigned char) (dw >> 24);
  1352. }
  1353.  
  1354. D3DXINLINE
  1355. D3DXCOLOR::D3DXCOLOR( CONST FLOAT* pf )
  1356. {
  1357. #ifdef D3DX_DEBUG
  1358.     if(!pf)
  1359.         return;
  1360. #endif
  1361.  
  1362.     r = pf[0];
  1363.     g = pf[1];
  1364.     b = pf[2];
  1365.     a = pf[3];
  1366. }
  1367.  
  1368. D3DXINLINE
  1369. D3DXCOLOR::D3DXCOLOR( CONST D3DXFLOAT16* pf )
  1370. {
  1371. #ifdef D3DX_DEBUG
  1372.     if(!pf)
  1373.         return;
  1374. #endif
  1375.  
  1376.     D3DXFloat16To32Array(&r, pf, 4);
  1377. }
  1378.  
  1379. D3DXINLINE
  1380. D3DXCOLOR::D3DXCOLOR( CONST D3DCOLORVALUE& c )
  1381. {
  1382.     r = c.r;
  1383.     g = c.g;
  1384.     b = c.b;
  1385.     a = c.a;
  1386. }
  1387.  
  1388. D3DXINLINE
  1389. D3DXCOLOR::D3DXCOLOR( FLOAT fr, FLOAT fg, FLOAT fb, FLOAT fa )
  1390. {
  1391.     r = fr;
  1392.     g = fg;
  1393.     b = fb;
  1394.     a = fa;
  1395. }
  1396.  
  1397.  
  1398. // casting
  1399. D3DXINLINE
  1400. D3DXCOLOR::operator DWORD () const
  1401. {
  1402.     DWORD dwR = r >= 1.0f ? 0xff : r <= 0.0f ? 0x00 : (DWORD) (r * 255.0f + 0.5f);
  1403.     DWORD dwG = g >= 1.0f ? 0xff : g <= 0.0f ? 0x00 : (DWORD) (g * 255.0f + 0.5f);
  1404.     DWORD dwB = b >= 1.0f ? 0xff : b <= 0.0f ? 0x00 : (DWORD) (b * 255.0f + 0.5f);
  1405.     DWORD dwA = a >= 1.0f ? 0xff : a <= 0.0f ? 0x00 : (DWORD) (a * 255.0f + 0.5f);
  1406.  
  1407.     return (dwA << 24) | (dwR << 16) | (dwG << 8) | dwB;
  1408. }
  1409.  
  1410.  
  1411. D3DXINLINE
  1412. D3DXCOLOR::operator FLOAT * ()
  1413. {
  1414.     return (FLOAT *) &r;
  1415. }
  1416.  
  1417. D3DXINLINE
  1418. D3DXCOLOR::operator CONST FLOAT * () const
  1419. {
  1420.     return (CONST FLOAT *) &r;
  1421. }
  1422.  
  1423.  
  1424. D3DXINLINE
  1425. D3DXCOLOR::operator D3DCOLORVALUE * ()
  1426. {
  1427.     return (D3DCOLORVALUE *) &r;
  1428. }
  1429.  
  1430. D3DXINLINE
  1431. D3DXCOLOR::operator CONST D3DCOLORVALUE * () const
  1432. {
  1433.     return (CONST D3DCOLORVALUE *) &r;
  1434. }
  1435.  
  1436.  
  1437. D3DXINLINE
  1438. D3DXCOLOR::operator D3DCOLORVALUE& ()
  1439. {
  1440.     return *((D3DCOLORVALUE *) &r);
  1441. }
  1442.  
  1443. D3DXINLINE
  1444. D3DXCOLOR::operator CONST D3DCOLORVALUE& () const
  1445. {
  1446.     return *((CONST D3DCOLORVALUE *) &r);
  1447. }
  1448.  
  1449.  
  1450. // assignment operators
  1451. D3DXINLINE D3DXCOLOR&
  1452. D3DXCOLOR::operator += ( CONST D3DXCOLOR& c )
  1453. {
  1454.     r += c.r;
  1455.     g += c.g;
  1456.     b += c.b;
  1457.     a += c.a;
  1458.     return *this;
  1459. }
  1460.  
  1461. D3DXINLINE D3DXCOLOR&
  1462. D3DXCOLOR::operator -= ( CONST D3DXCOLOR& c )
  1463. {
  1464.     r -= c.r;
  1465.     g -= c.g;
  1466.     b -= c.b;
  1467.     a -= c.a;
  1468.     return *this;
  1469. }
  1470.  
  1471. D3DXINLINE D3DXCOLOR&
  1472. D3DXCOLOR::operator *= ( FLOAT f )
  1473. {
  1474.     r *= f;
  1475.     g *= f;
  1476.     b *= f;
  1477.     a *= f;
  1478.     return *this;
  1479. }
  1480.  
  1481. D3DXINLINE D3DXCOLOR&
  1482. D3DXCOLOR::operator /= ( FLOAT f )
  1483. {
  1484.     FLOAT fInv = 1.0f / f;
  1485.     r *= fInv;
  1486.     g *= fInv;
  1487.     b *= fInv;
  1488.     a *= fInv;
  1489.     return *this;
  1490. }
  1491.  
  1492.  
  1493. // unary operators
  1494. D3DXINLINE D3DXCOLOR
  1495. D3DXCOLOR::operator + () const
  1496. {
  1497.     return *this;
  1498. }
  1499.  
  1500. D3DXINLINE D3DXCOLOR
  1501. D3DXCOLOR::operator - () const
  1502. {
  1503.     return D3DXCOLOR(-r, -g, -b, -a);
  1504. }
  1505.  
  1506.  
  1507. // binary operators
  1508. D3DXINLINE D3DXCOLOR
  1509. D3DXCOLOR::operator + ( CONST D3DXCOLOR& c ) const
  1510. {
  1511.     return D3DXCOLOR(r + c.r, g + c.g, b + c.b, a + c.a);
  1512. }
  1513.  
  1514. D3DXINLINE D3DXCOLOR
  1515. D3DXCOLOR::operator - ( CONST D3DXCOLOR& c ) const
  1516. {
  1517.     return D3DXCOLOR(r - c.r, g - c.g, b - c.b, a - c.a);
  1518. }
  1519.  
  1520. D3DXINLINE D3DXCOLOR
  1521. D3DXCOLOR::operator * ( FLOAT f ) const
  1522. {
  1523.     return D3DXCOLOR(r * f, g * f, b * f, a * f);
  1524. }
  1525.  
  1526. D3DXINLINE D3DXCOLOR
  1527. D3DXCOLOR::operator / ( FLOAT f ) const
  1528. {
  1529.     FLOAT fInv = 1.0f / f;
  1530.     return D3DXCOLOR(r * fInv, g * fInv, b * fInv, a * fInv);
  1531. }
  1532.  
  1533.  
  1534. D3DXINLINE D3DXCOLOR
  1535. operator * (FLOAT f, CONST D3DXCOLOR& c )
  1536. {
  1537.     return D3DXCOLOR(f * c.r, f * c.g, f * c.b, f * c.a);
  1538. }
  1539.  
  1540.  
  1541. D3DXINLINE BOOL
  1542. D3DXCOLOR::operator == ( CONST D3DXCOLOR& c ) const
  1543. {
  1544.     return r == c.r && g == c.g && b == c.b && a == c.a;
  1545. }
  1546.  
  1547. D3DXINLINE BOOL
  1548. D3DXCOLOR::operator != ( CONST D3DXCOLOR& c ) const
  1549. {
  1550.     return r != c.r || g != c.g || b != c.b || a != c.a;
  1551. }
  1552.  
  1553.  
  1554. #endif //__cplusplus
  1555.  
  1556.  
  1557.  
  1558. //===========================================================================
  1559. //
  1560. // Inline functions
  1561. //
  1562. //===========================================================================
  1563.  
  1564.  
  1565. //--------------------------
  1566. // 2D Vector
  1567. //--------------------------
  1568.  
  1569. D3DXINLINE FLOAT D3DXVec2Length
  1570.     ( CONST D3DXVECTOR2 *pV )
  1571. {
  1572. #ifdef D3DX_DEBUG
  1573.     if(!pV)
  1574.         return 0.0f;
  1575. #endif
  1576.  
  1577. #ifdef __cplusplus
  1578.     return sqrtf(pV->x * pV->x + pV->y * pV->y);
  1579. #else
  1580.     return (FLOAT) sqrt(pV->x * pV->x + pV->y * pV->y);
  1581. #endif
  1582. }
  1583.  
  1584. D3DXINLINE FLOAT D3DXVec2LengthSq
  1585.     ( CONST D3DXVECTOR2 *pV )
  1586. {
  1587. #ifdef D3DX_DEBUG
  1588.     if(!pV)
  1589.         return 0.0f;
  1590. #endif
  1591.  
  1592.     return pV->x * pV->x + pV->y * pV->y;
  1593. }
  1594.  
  1595. D3DXINLINE FLOAT D3DXVec2Dot
  1596.     ( CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 )
  1597. {
  1598. #ifdef D3DX_DEBUG
  1599.     if(!pV1 || !pV2)
  1600.         return 0.0f;
  1601. #endif
  1602.  
  1603.     return pV1->x * pV2->x + pV1->y * pV2->y;
  1604. }
  1605.  
  1606. D3DXINLINE FLOAT D3DXVec2CCW
  1607.     ( CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 )
  1608. {
  1609. #ifdef D3DX_DEBUG
  1610.     if(!pV1 || !pV2)
  1611.         return 0.0f;
  1612. #endif
  1613.  
  1614.     return pV1->x * pV2->y - pV1->y * pV2->x;
  1615. }
  1616.  
  1617. D3DXINLINE D3DXVECTOR2* D3DXVec2Add
  1618.     ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 )
  1619. {
  1620. #ifdef D3DX_DEBUG
  1621.     if(!pOut || !pV1 || !pV2)
  1622.         return NULL;
  1623. #endif
  1624.  
  1625.     pOut->x = pV1->x + pV2->x;
  1626.     pOut->y = pV1->y + pV2->y;
  1627.     return pOut;
  1628. }
  1629.  
  1630. D3DXINLINE D3DXVECTOR2* D3DXVec2Subtract
  1631.     ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 )
  1632. {
  1633. #ifdef D3DX_DEBUG
  1634.     if(!pOut || !pV1 || !pV2)
  1635.         return NULL;
  1636. #endif
  1637.  
  1638.     pOut->x = pV1->x - pV2->x;
  1639.     pOut->y = pV1->y - pV2->y;
  1640.     return pOut;
  1641. }
  1642.  
  1643. D3DXINLINE D3DXVECTOR2* D3DXVec2Minimize
  1644.     ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 )
  1645. {
  1646. #ifdef D3DX_DEBUG
  1647.     if(!pOut || !pV1 || !pV2)
  1648.         return NULL;
  1649. #endif
  1650.  
  1651.     pOut->x = pV1->x < pV2->x ? pV1->x : pV2->x;
  1652.     pOut->y = pV1->y < pV2->y ? pV1->y : pV2->y;
  1653.     return pOut;
  1654. }
  1655.  
  1656. D3DXINLINE D3DXVECTOR2* D3DXVec2Maximize
  1657.     ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2 )
  1658. {
  1659. #ifdef D3DX_DEBUG
  1660.     if(!pOut || !pV1 || !pV2)
  1661.         return NULL;
  1662. #endif
  1663.  
  1664.     pOut->x = pV1->x > pV2->x ? pV1->x : pV2->x;
  1665.     pOut->y = pV1->y > pV2->y ? pV1->y : pV2->y;
  1666.     return pOut;
  1667. }
  1668.  
  1669. D3DXINLINE D3DXVECTOR2* D3DXVec2Scale
  1670.     ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV, FLOAT s )
  1671. {
  1672. #ifdef D3DX_DEBUG
  1673.     if(!pOut || !pV)
  1674.         return NULL;
  1675. #endif
  1676.  
  1677.     pOut->x = pV->x * s;
  1678.     pOut->y = pV->y * s;
  1679.     return pOut;
  1680. }
  1681.  
  1682. D3DXINLINE D3DXVECTOR2* D3DXVec2Lerp
  1683.     ( D3DXVECTOR2 *pOut, CONST D3DXVECTOR2 *pV1, CONST D3DXVECTOR2 *pV2,
  1684.       FLOAT s )
  1685. {
  1686. #ifdef D3DX_DEBUG
  1687.     if(!pOut || !pV1 || !pV2)
  1688.         return NULL;
  1689. #endif
  1690.  
  1691.     pOut->x = pV1->x + s * (pV2->x - pV1->x);
  1692.     pOut->y = pV1->y + s * (pV2->y - pV1->y);
  1693.     return pOut;
  1694. }
  1695.  
  1696.  
  1697. //--------------------------
  1698. // 3D Vector
  1699. //--------------------------
  1700.  
  1701. D3DXINLINE FLOAT D3DXVec3Length
  1702.     ( CONST D3DXVECTOR3 *pV )
  1703. {
  1704. #ifdef D3DX_DEBUG
  1705.     if(!pV)
  1706.         return 0.0f;
  1707. #endif
  1708.  
  1709. #ifdef __cplusplus
  1710.     return sqrtf(pV->x * pV->x + pV->y * pV->y + pV->z * pV->z);
  1711. #else
  1712.     return (FLOAT) sqrt(pV->x * pV->x + pV->y * pV->y + pV->z * pV->z);
  1713. #endif
  1714. }
  1715.  
  1716. D3DXINLINE FLOAT D3DXVec3LengthSq
  1717.     ( CONST D3DXVECTOR3 *pV )
  1718. {
  1719. #ifdef D3DX_DEBUG
  1720.     if(!pV)
  1721.         return 0.0f;
  1722. #endif
  1723.  
  1724.     return pV->x * pV->x + pV->y * pV->y + pV->z * pV->z;
  1725. }
  1726.  
  1727. D3DXINLINE FLOAT D3DXVec3Dot
  1728.     ( CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )
  1729. {
  1730. #ifdef D3DX_DEBUG
  1731.     if(!pV1 || !pV2)
  1732.         return 0.0f;
  1733. #endif
  1734.  
  1735.     return pV1->x * pV2->x + pV1->y * pV2->y + pV1->z * pV2->z;
  1736. }
  1737.  
  1738. D3DXINLINE D3DXVECTOR3* D3DXVec3Cross
  1739.     ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )
  1740. {
  1741.     D3DXVECTOR3 v;
  1742.  
  1743. #ifdef D3DX_DEBUG
  1744.     if(!pOut || !pV1 || !pV2)
  1745.         return NULL;
  1746. #endif
  1747.  
  1748.     v.x = pV1->y * pV2->z - pV1->z * pV2->y;
  1749.     v.y = pV1->z * pV2->x - pV1->x * pV2->z;
  1750.     v.z = pV1->x * pV2->y - pV1->y * pV2->x;
  1751.  
  1752.     *pOut = v;
  1753.     return pOut;
  1754. }
  1755.  
  1756. D3DXINLINE D3DXVECTOR3* D3DXVec3Add
  1757.     ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )
  1758. {
  1759. #ifdef D3DX_DEBUG
  1760.     if(!pOut || !pV1 || !pV2)
  1761.         return NULL;
  1762. #endif
  1763.  
  1764.     pOut->x = pV1->x + pV2->x;
  1765.     pOut->y = pV1->y + pV2->y;
  1766.     pOut->z = pV1->z + pV2->z;
  1767.     return pOut;
  1768. }
  1769.  
  1770. D3DXINLINE D3DXVECTOR3* D3DXVec3Subtract
  1771.     ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )
  1772. {
  1773. #ifdef D3DX_DEBUG
  1774.     if(!pOut || !pV1 || !pV2)
  1775.         return NULL;
  1776. #endif
  1777.  
  1778.     pOut->x = pV1->x - pV2->x;
  1779.     pOut->y = pV1->y - pV2->y;
  1780.     pOut->z = pV1->z - pV2->z;
  1781.     return pOut;
  1782. }
  1783.  
  1784. D3DXINLINE D3DXVECTOR3* D3DXVec3Minimize
  1785.     ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )
  1786. {
  1787. #ifdef D3DX_DEBUG
  1788.     if(!pOut || !pV1 || !pV2)
  1789.         return NULL;
  1790. #endif
  1791.  
  1792.     pOut->x = pV1->x < pV2->x ? pV1->x : pV2->x;
  1793.     pOut->y = pV1->y < pV2->y ? pV1->y : pV2->y;
  1794.     pOut->z = pV1->z < pV2->z ? pV1->z : pV2->z;
  1795.     return pOut;
  1796. }
  1797.  
  1798. D3DXINLINE D3DXVECTOR3* D3DXVec3Maximize
  1799.     ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )
  1800. {
  1801. #ifdef D3DX_DEBUG
  1802.     if(!pOut || !pV1 || !pV2)
  1803.         return NULL;
  1804. #endif
  1805.  
  1806.     pOut->x = pV1->x > pV2->x ? pV1->x : pV2->x;
  1807.     pOut->y = pV1->y > pV2->y ? pV1->y : pV2->y;
  1808.     pOut->z = pV1->z > pV2->z ? pV1->z : pV2->z;
  1809.     return pOut;
  1810. }
  1811.  
  1812. D3DXINLINE D3DXVECTOR3* D3DXVec3Scale
  1813.     ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV, FLOAT s)
  1814. {
  1815. #ifdef D3DX_DEBUG
  1816.     if(!pOut || !pV)
  1817.         return NULL;
  1818. #endif
  1819.  
  1820.     pOut->x = pV->x * s;
  1821.     pOut->y = pV->y * s;
  1822.     pOut->z = pV->z * s;
  1823.     return pOut;
  1824. }
  1825.  
  1826. D3DXINLINE D3DXVECTOR3* D3DXVec3Lerp
  1827.     ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2,
  1828.       FLOAT s )
  1829. {
  1830. #ifdef D3DX_DEBUG
  1831.     if(!pOut || !pV1 || !pV2)
  1832.         return NULL;
  1833. #endif
  1834.  
  1835.     pOut->x = pV1->x + s * (pV2->x - pV1->x);
  1836.     pOut->y = pV1->y + s * (pV2->y - pV1->y);
  1837.     pOut->z = pV1->z + s * (pV2->z - pV1->z);
  1838.     return pOut;
  1839. }
  1840.  
  1841.  
  1842. //--------------------------
  1843. // 4D Vector
  1844. //--------------------------
  1845.  
  1846. D3DXINLINE FLOAT D3DXVec4Length
  1847.     ( CONST D3DXVECTOR4 *pV )
  1848. {
  1849. #ifdef D3DX_DEBUG
  1850.     if(!pV)
  1851.         return 0.0f;
  1852. #endif
  1853.  
  1854. #ifdef __cplusplus
  1855.     return sqrtf(pV->x * pV->x + pV->y * pV->y + pV->z * pV->z + pV->w * pV->w);
  1856. #else
  1857.     return (FLOAT) sqrt(pV->x * pV->x + pV->y * pV->y + pV->z * pV->z + pV->w * pV->w);
  1858. #endif
  1859. }
  1860.  
  1861. D3DXINLINE FLOAT D3DXVec4LengthSq
  1862.     ( CONST D3DXVECTOR4 *pV )
  1863. {
  1864. #ifdef D3DX_DEBUG
  1865.     if(!pV)
  1866.         return 0.0f;
  1867. #endif
  1868.  
  1869.     return pV->x * pV->x + pV->y * pV->y + pV->z * pV->z + pV->w * pV->w;
  1870. }
  1871.  
  1872. D3DXINLINE FLOAT D3DXVec4Dot
  1873.     ( CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2 )
  1874. {
  1875. #ifdef D3DX_DEBUG
  1876.     if(!pV1 || !pV2)
  1877.         return 0.0f;
  1878. #endif
  1879.  
  1880.     return pV1->x * pV2->x + pV1->y * pV2->y + pV1->z * pV2->z + pV1->w * pV2->w;
  1881. }
  1882.  
  1883. D3DXINLINE D3DXVECTOR4* D3DXVec4Add
  1884.     ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2)
  1885. {
  1886. #ifdef D3DX_DEBUG
  1887.     if(!pOut || !pV1 || !pV2)
  1888.         return NULL;
  1889. #endif
  1890.  
  1891.     pOut->x = pV1->x + pV2->x;
  1892.     pOut->y = pV1->y + pV2->y;
  1893.     pOut->z = pV1->z + pV2->z;
  1894.     pOut->w = pV1->w + pV2->w;
  1895.     return pOut;
  1896. }
  1897.  
  1898. D3DXINLINE D3DXVECTOR4* D3DXVec4Subtract
  1899.     ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2)
  1900. {
  1901. #ifdef D3DX_DEBUG
  1902.     if(!pOut || !pV1 || !pV2)
  1903.         return NULL;
  1904. #endif
  1905.  
  1906.     pOut->x = pV1->x - pV2->x;
  1907.     pOut->y = pV1->y - pV2->y;
  1908.     pOut->z = pV1->z - pV2->z;
  1909.     pOut->w = pV1->w - pV2->w;
  1910.     return pOut;
  1911. }
  1912.  
  1913. D3DXINLINE D3DXVECTOR4* D3DXVec4Minimize
  1914.     ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2)
  1915. {
  1916. #ifdef D3DX_DEBUG
  1917.     if(!pOut || !pV1 || !pV2)
  1918.         return NULL;
  1919. #endif
  1920.  
  1921.     pOut->x = pV1->x < pV2->x ? pV1->x : pV2->x;
  1922.     pOut->y = pV1->y < pV2->y ? pV1->y : pV2->y;
  1923.     pOut->z = pV1->z < pV2->z ? pV1->z : pV2->z;
  1924.     pOut->w = pV1->w < pV2->w ? pV1->w : pV2->w;
  1925.     return pOut;
  1926. }
  1927.  
  1928. D3DXINLINE D3DXVECTOR4* D3DXVec4Maximize
  1929.     ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2)
  1930. {
  1931. #ifdef D3DX_DEBUG
  1932.     if(!pOut || !pV1 || !pV2)
  1933.         return NULL;
  1934. #endif
  1935.  
  1936.     pOut->x = pV1->x > pV2->x ? pV1->x : pV2->x;
  1937.     pOut->y = pV1->y > pV2->y ? pV1->y : pV2->y;
  1938.     pOut->z = pV1->z > pV2->z ? pV1->z : pV2->z;
  1939.     pOut->w = pV1->w > pV2->w ? pV1->w : pV2->w;
  1940.     return pOut;
  1941. }
  1942.  
  1943. D3DXINLINE D3DXVECTOR4* D3DXVec4Scale
  1944.     ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV, FLOAT s)
  1945. {
  1946. #ifdef D3DX_DEBUG
  1947.     if(!pOut || !pV)
  1948.         return NULL;
  1949. #endif
  1950.  
  1951.     pOut->x = pV->x * s;
  1952.     pOut->y = pV->y * s;
  1953.     pOut->z = pV->z * s;
  1954.     pOut->w = pV->w * s;
  1955.     return pOut;
  1956. }
  1957.  
  1958. D3DXINLINE D3DXVECTOR4* D3DXVec4Lerp
  1959.     ( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV1, CONST D3DXVECTOR4 *pV2,
  1960.       FLOAT s )
  1961. {
  1962. #ifdef D3DX_DEBUG
  1963.     if(!pOut || !pV1 || !pV2)
  1964.         return NULL;
  1965. #endif
  1966.  
  1967.     pOut->x = pV1->x + s * (pV2->x - pV1->x);
  1968.     pOut->y = pV1->y + s * (pV2->y - pV1->y);
  1969.     pOut->z = pV1->z + s * (pV2->z - pV1->z);
  1970.     pOut->w = pV1->w + s * (pV2->w - pV1->w);
  1971.     return pOut;
  1972. }
  1973.  
  1974.  
  1975. //--------------------------
  1976. // 4D Matrix
  1977. //--------------------------
  1978.  
  1979. D3DXINLINE D3DXMATRIX* D3DXMatrixIdentity
  1980.     ( D3DXMATRIX *pOut )
  1981. {
  1982. #ifdef D3DX_DEBUG
  1983.     if(!pOut)
  1984.         return NULL;
  1985. #endif
  1986.  
  1987.     pOut->m[0][1] = pOut->m[0][2] = pOut->m[0][3] =
  1988.     pOut->m[1][0] = pOut->m[1][2] = pOut->m[1][3] =
  1989.     pOut->m[2][0] = pOut->m[2][1] = pOut->m[2][3] =
  1990.     pOut->m[3][0] = pOut->m[3][1] = pOut->m[3][2] = 0.0f;
  1991.  
  1992.     pOut->m[0][0] = pOut->m[1][1] = pOut->m[2][2] = pOut->m[3][3] = 1.0f;
  1993.     return pOut;
  1994. }
  1995.  
  1996.  
  1997. D3DXINLINE BOOL D3DXMatrixIsIdentity
  1998.     ( CONST D3DXMATRIX *pM )
  1999. {
  2000. #ifdef D3DX_DEBUG
  2001.     if(!pM)
  2002.         return FALSE;
  2003. #endif
  2004.  
  2005.     return pM->m[0][0] == 1.0f && pM->m[0][1] == 0.0f && pM->m[0][2] == 0.0f && pM->m[0][3] == 0.0f &&
  2006.            pM->m[1][0] == 0.0f && pM->m[1][1] == 1.0f && pM->m[1][2] == 0.0f && pM->m[1][3] == 0.0f &&
  2007.            pM->m[2][0] == 0.0f && pM->m[2][1] == 0.0f && pM->m[2][2] == 1.0f && pM->m[2][3] == 0.0f &&
  2008.            pM->m[3][0] == 0.0f && pM->m[3][1] == 0.0f && pM->m[3][2] == 0.0f && pM->m[3][3] == 1.0f;
  2009. }
  2010.  
  2011.  
  2012. //--------------------------
  2013. // Quaternion
  2014. //--------------------------
  2015.  
  2016. D3DXINLINE FLOAT D3DXQuaternionLength
  2017.     ( CONST D3DXQUATERNION *pQ )
  2018. {
  2019. #ifdef D3DX_DEBUG
  2020.     if(!pQ)
  2021.         return 0.0f;
  2022. #endif
  2023.  
  2024. #ifdef __cplusplus
  2025.     return sqrtf(pQ->x * pQ->x + pQ->y * pQ->y + pQ->z * pQ->z + pQ->w * pQ->w);
  2026. #else
  2027.     return (FLOAT) sqrt(pQ->x * pQ->x + pQ->y * pQ->y + pQ->z * pQ->z + pQ->w * pQ->w);
  2028. #endif
  2029. }
  2030.  
  2031. D3DXINLINE FLOAT D3DXQuaternionLengthSq
  2032.     ( CONST D3DXQUATERNION *pQ )
  2033. {
  2034. #ifdef D3DX_DEBUG
  2035.     if(!pQ)
  2036.         return 0.0f;
  2037. #endif
  2038.  
  2039.     return pQ->x * pQ->x + pQ->y * pQ->y + pQ->z * pQ->z + pQ->w * pQ->w;
  2040. }
  2041.  
  2042. D3DXINLINE FLOAT D3DXQuaternionDot
  2043.     ( CONST D3DXQUATERNION *pQ1, CONST D3DXQUATERNION *pQ2 )
  2044. {
  2045. #ifdef D3DX_DEBUG
  2046.     if(!pQ1 || !pQ2)
  2047.         return 0.0f;
  2048. #endif
  2049.  
  2050.     return pQ1->x * pQ2->x + pQ1->y * pQ2->y + pQ1->z * pQ2->z + pQ1->w * pQ2->w;
  2051. }
  2052.  
  2053.  
  2054. D3DXINLINE D3DXQUATERNION* D3DXQuaternionIdentity
  2055.     ( D3DXQUATERNION *pOut )
  2056. {
  2057. #ifdef D3DX_DEBUG
  2058.     if(!pOut)
  2059.         return NULL;
  2060. #endif
  2061.  
  2062.     pOut->x = pOut->y = pOut->z = 0.0f;
  2063.     pOut->w = 1.0f;
  2064.     return pOut;
  2065. }
  2066.  
  2067. D3DXINLINE BOOL D3DXQuaternionIsIdentity
  2068.     ( CONST D3DXQUATERNION *pQ )
  2069. {
  2070. #ifdef D3DX_DEBUG
  2071.     if(!pQ)
  2072.         return FALSE;
  2073. #endif
  2074.  
  2075.     return pQ->x == 0.0f && pQ->y == 0.0f && pQ->z == 0.0f && pQ->w == 1.0f;
  2076. }
  2077.  
  2078.  
  2079. D3DXINLINE D3DXQUATERNION* D3DXQuaternionConjugate
  2080.     ( D3DXQUATERNION *pOut, CONST D3DXQUATERNION *pQ )
  2081. {
  2082. #ifdef D3DX_DEBUG
  2083.     if(!pOut || !pQ)
  2084.         return NULL;
  2085. #endif
  2086.  
  2087.     pOut->x = -pQ->x;
  2088.     pOut->y = -pQ->y;
  2089.     pOut->z = -pQ->z;
  2090.     pOut->w =  pQ->w;
  2091.     return pOut;
  2092. }
  2093.  
  2094.  
  2095. //--------------------------
  2096. // Plane
  2097. //--------------------------
  2098.  
  2099. D3DXINLINE FLOAT D3DXPlaneDot
  2100.     ( CONST D3DXPLANE *pP, CONST D3DXVECTOR4 *pV)
  2101. {
  2102. #ifdef D3DX_DEBUG
  2103.     if(!pP || !pV)
  2104.         return 0.0f;
  2105. #endif
  2106.  
  2107.     return pP->a * pV->x + pP->b * pV->y + pP->c * pV->z + pP->d * pV->w;
  2108. }
  2109.  
  2110. D3DXINLINE FLOAT D3DXPlaneDotCoord
  2111.     ( CONST D3DXPLANE *pP, CONST D3DXVECTOR3 *pV)
  2112. {
  2113. #ifdef D3DX_DEBUG
  2114.     if(!pP || !pV)
  2115.         return 0.0f;
  2116. #endif
  2117.  
  2118.     return pP->a * pV->x + pP->b * pV->y + pP->c * pV->z + pP->d;
  2119. }
  2120.  
  2121. D3DXINLINE FLOAT D3DXPlaneDotNormal
  2122.     ( CONST D3DXPLANE *pP, CONST D3DXVECTOR3 *pV)
  2123. {
  2124. #ifdef D3DX_DEBUG
  2125.     if(!pP || !pV)
  2126.         return 0.0f;
  2127. #endif
  2128.  
  2129.     return pP->a * pV->x + pP->b * pV->y + pP->c * pV->z;
  2130. }
  2131.  
  2132. D3DXINLINE D3DXPLANE* D3DXPlaneScale
  2133.     (D3DXPLANE *pOut, CONST D3DXPLANE *pP, FLOAT s)
  2134. {
  2135. #ifdef D3DX_DEBUG
  2136.     if(!pOut || !pP)
  2137.         return NULL;
  2138. #endif
  2139.  
  2140.     pOut->a = pP->a * s;
  2141.     pOut->b = pP->b * s;
  2142.     pOut->c = pP->c * s;
  2143.     pOut->d = pP->d * s;
  2144.     return pOut;
  2145. }
  2146.  
  2147.  
  2148. //--------------------------
  2149. // Color
  2150. //--------------------------
  2151.  
  2152. D3DXINLINE D3DXCOLOR* D3DXColorNegative
  2153.     (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC)
  2154. {
  2155. #ifdef D3DX_DEBUG
  2156.     if(!pOut || !pC)
  2157.         return NULL;
  2158. #endif
  2159.  
  2160.     pOut->r = 1.0f - pC->r;
  2161.     pOut->g = 1.0f - pC->g;
  2162.     pOut->b = 1.0f - pC->b;
  2163.     pOut->a = pC->a;
  2164.     return pOut;
  2165. }
  2166.  
  2167. D3DXINLINE D3DXCOLOR* D3DXColorAdd
  2168.     (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC1, CONST D3DXCOLOR *pC2)
  2169. {
  2170. #ifdef D3DX_DEBUG
  2171.     if(!pOut || !pC1 || !pC2)
  2172.         return NULL;
  2173. #endif
  2174.  
  2175.     pOut->r = pC1->r + pC2->r;
  2176.     pOut->g = pC1->g + pC2->g;
  2177.     pOut->b = pC1->b + pC2->b;
  2178.     pOut->a = pC1->a + pC2->a;
  2179.     return pOut;
  2180. }
  2181.  
  2182. D3DXINLINE D3DXCOLOR* D3DXColorSubtract
  2183.     (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC1, CONST D3DXCOLOR *pC2)
  2184. {
  2185. #ifdef D3DX_DEBUG
  2186.     if(!pOut || !pC1 || !pC2)
  2187.         return NULL;
  2188. #endif
  2189.  
  2190.     pOut->r = pC1->r - pC2->r;
  2191.     pOut->g = pC1->g - pC2->g;
  2192.     pOut->b = pC1->b - pC2->b;
  2193.     pOut->a = pC1->a - pC2->a;
  2194.     return pOut;
  2195. }
  2196.  
  2197. D3DXINLINE D3DXCOLOR* D3DXColorScale
  2198.     (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC, FLOAT s)
  2199. {
  2200. #ifdef D3DX_DEBUG
  2201.     if(!pOut || !pC)
  2202.         return NULL;
  2203. #endif
  2204.  
  2205.     pOut->r = pC->r * s;
  2206.     pOut->g = pC->g * s;
  2207.     pOut->b = pC->b * s;
  2208.     pOut->a = pC->a * s;
  2209.     return pOut;
  2210. }
  2211.  
  2212. D3DXINLINE D3DXCOLOR* D3DXColorModulate
  2213.     (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC1, CONST D3DXCOLOR *pC2)
  2214. {
  2215. #ifdef D3DX_DEBUG
  2216.     if(!pOut || !pC1 || !pC2)
  2217.         return NULL;
  2218. #endif
  2219.  
  2220.     pOut->r = pC1->r * pC2->r;
  2221.     pOut->g = pC1->g * pC2->g;
  2222.     pOut->b = pC1->b * pC2->b;
  2223.     pOut->a = pC1->a * pC2->a;
  2224.     return pOut;
  2225. }
  2226.  
  2227. D3DXINLINE D3DXCOLOR* D3DXColorLerp
  2228.     (D3DXCOLOR *pOut, CONST D3DXCOLOR *pC1, CONST D3DXCOLOR *pC2, FLOAT s)
  2229. {
  2230. #ifdef D3DX_DEBUG
  2231.     if(!pOut || !pC1 || !pC2)
  2232.         return NULL;
  2233. #endif
  2234.  
  2235.     pOut->r = pC1->r + s * (pC2->r - pC1->r);
  2236.     pOut->g = pC1->g + s * (pC2->g - pC1->g);
  2237.     pOut->b = pC1->b + s * (pC2->b - pC1->b);
  2238.     pOut->a = pC1->a + s * (pC2->a - pC1->a);
  2239.     return pOut;
  2240. }
  2241.  
  2242.  
  2243. #endif // __D3DX9MATH_INL__
  2244.  
  2245.